home *** CD-ROM | disk | FTP | other *** search
/ Game.EXE 2001 January / execd1200.iso / Shareware / Blocks 3 / setup.exe / Source / GFX.C < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-06  |  12.6 KB  |  408 lines
  1. #include <allegro.h>
  2. #include <jgmod.h>
  3. #include <blocks3.h>
  4.  
  5.  
  6. void DirtyList(int x,int y, int z, int w, int h, BITMAP *pic)
  7. {
  8.  dirty[dirty_count].x = x;
  9.  dirty[dirty_count].y = y;
  10.  dirty[dirty_count].z = z;
  11.  dirty[dirty_count].w = w;
  12.  dirty[dirty_count].h = h;
  13.  dirty[dirty_count].pic = pic;
  14.  
  15.  dirty_count++;
  16. }
  17.  
  18. /*void Draw_Screen(void)
  19. {
  20.  int i, j, k;
  21.  
  22.  for (j = 0; j < 15; j++)
  23.  {
  24.   for (k = 0; k < dirty_count; k++)
  25.   {
  26.    if ((dirty[k].y > j*32 - 1) && (dirty[k].y < j*32+32))
  27.    {
  28.     Draw_Block(dirty[k].x/32, j, 0, temp);
  29.     Draw_Block(dirty[k].x/32, j - 1, 0, temp);
  30.     Draw_Block(dirty[k].x/32, j - 1, 1, temp);
  31.  
  32.     if (dirty[k].x%32)
  33.     {
  34.      Draw_Block(dirty[k].x/32 + 1, j, 0, temp);
  35.      Draw_Block(dirty[k].x/32 + 1, j - 1, 0, temp);
  36.      Draw_Block(dirty[k].x/32 + 1, j - 1, 1, temp);
  37.     }
  38.    }
  39.   }
  40.  
  41.   for (k = 0; k < dirty_count; k++)
  42.   {
  43.    if ((dirty[k].y > j*32 - 1) && (dirty[k].y < j*32+32))
  44.    {
  45.     masked_blit(dirty[k].pic, temp, 0, 0, dirty[k].x, dirty[k].y - dirty[k].z, dirty[k].w, dirty[k].h);
  46.    }
  47.   }
  48.  
  49.   for (k = 0; k < dirty_count; k++)
  50.   {
  51.    if ((dirty[k].y > j*32 - 1) && (dirty[k].y < j*32+32))
  52.    {
  53.     Draw_Block(dirty[k].x/32, j, 1, temp);
  54.     Draw_Block(dirty[k].x/32, j + 1, 0, temp);
  55.     Draw_Block(dirty[k].x/32, j + 1, 1, temp);
  56.     Draw_Block(dirty[k].x/32, j + 2, 0, temp);
  57.     Draw_Block(dirty[k].x/32, j + 2, 1, temp);
  58.  
  59.     if (dirty[k].x%32)
  60.     {
  61.      Draw_Block(dirty[k].x/32 + 1, j, 1, temp);
  62.      Draw_Block(dirty[k].x/32 + 1, j + 1, 0, temp);
  63.      Draw_Block(dirty[k].x/32 + 1, j + 1, 1, temp);
  64.      Draw_Block(dirty[k].x/32 + 1, j + 2, 0, temp);
  65.      Draw_Block(dirty[k].x/32 + 1, j + 2, 1, temp);
  66.     }
  67.    }
  68.   }
  69.  }
  70.  
  71.  for (i = 0; i < dirty_count; i++)
  72.  blit(temp, screen, dirty[i].x - 1, dirty[i].y - dirty[i].z - 1, dirty[i].x - 1, dirty[i].y - dirty[i].z - 1, dirty[i].w + 2, dirty[i].h + 2);
  73.  
  74.  for (i = 0; i < dirty_count; i++)
  75.  blit(back, temp, dirty[i].x - 1, dirty[i].y - dirty[i].z - 1, dirty[i].x - 1, dirty[i].y - dirty[i].z - 1, dirty[i].w + 2, dirty[i].h + 2);
  76.  
  77.  dirty_count = 0;
  78. } */
  79.  
  80. void Draw_Map(void)
  81. {
  82.  int i, j, k, l;
  83.  
  84.  for (j = 0; j < 15; j+=2)
  85.  for (i = 0; i < 20; i+=2)
  86.  blit(gfx, back, 0, 200, i*32, j*32, 64, 64);
  87.  
  88.  blit(back, temp, 0, 0, 0, 0, 640, 480);
  89.  
  90.  for (k = 0; k < 2; k++)
  91.  for (j = 0; j < 15; j++)
  92.  for (i = 0; i < 20; i++)
  93.  {
  94.   if ((k == 0) || ((i != 0) && (i != 19) && (j != 0) && (j != 14))) Draw_Block(i, j, k, temp);
  95.  }
  96.  
  97.  rect(temp, 16, 16, 623, 463, 7);
  98. }
  99.  
  100. void Draw_Area(void)
  101. {
  102.  int i, j, k;
  103.  
  104.  for (i = 0; i < 20; i++)
  105.  for (j = 0; j < 15; j++)
  106.  map2[i][j] = 0;
  107.  
  108.  for (i = 0; i < dirty_count; i++)
  109.  {
  110.   map2[dirty[i].x/32][dirty[i].y/32] = 1;
  111.   map2[(dirty[i].x + 31)/32][dirty[i].y/32] = 1;
  112.  
  113.   map2[dirty[i].x/32][(dirty[i].y + 31)/32] = 1;
  114.   map2[(dirty[i].x + 31)/32][(dirty[i].y + 31)/32] = 1;
  115.  
  116.   map2[dirty[i].x/32 - 1][dirty[i].y/32] = 1;
  117.   map2[dirty[i].x/32][dirty[i].y/32 - 1] = 1;
  118.   map2[dirty[i].x/32 - 1][dirty[i].y/32 - 1] = 1;
  119.  
  120.   map2[(dirty[i].x + 31)/32 + 1][dirty[i].y/32] = 1;
  121.   map2[(dirty[i].x + 31)/32][dirty[i].y/32 - 1] = 1;
  122.   map2[(dirty[i].x + 31)/32 + 1][dirty[i].y/32 - 1] = 1;
  123.  
  124.   map2[dirty[i].x/32 - 1][(dirty[i].y + 31)/32] = 1;
  125.   map2[dirty[i].x/32][(dirty[i].y + 31)/32 + 1] = 1;
  126.   map2[dirty[i].x/32 - 1][(dirty[i].y + 31)/32 + 1] = 1;
  127.  
  128.   map2[(dirty[i].x + 31)/32 + 1][(dirty[i].y + 31)/32] = 1;
  129.   map2[(dirty[i].x + 31)/32][(dirty[i].y + 31)/32 + 1] = 1;
  130.   map2[(dirty[i].x + 31)/32 + 1][(dirty[i].y + 31)/32 + 1] = 1;
  131.  }
  132. }
  133.  
  134. void Sort_Dirty(void)
  135. {
  136.  int i, j, k;
  137.  
  138.  j = 0;
  139.  
  140.  for (k = 0; k < dirty_count; k++)
  141.  {
  142.   i = 0;
  143.  
  144.   while (i < dirty_count)
  145.   {
  146.    if ((i != j) && (dirty[i].y < dirty[j].y))
  147.    {
  148.     j = i;
  149.    }
  150.    i++;
  151.   }
  152.  
  153.   dirty_sort[k].x = dirty[j].x;
  154.   dirty_sort[k].y = dirty[j].y;
  155.   dirty_sort[k].z = dirty[j].z;
  156.   dirty_sort[k].w = dirty[j].w;
  157.   dirty_sort[k].h = dirty[j].h;
  158.   dirty_sort[k].pic = dirty[j].pic;
  159.  
  160.   dirty[j].y = 500;
  161.  
  162.   j = 0;
  163.  
  164.   while (dirty[j].y != 500)
  165.   j++;
  166.  }
  167.  
  168.  for (i = 0; i < dirty_count; i++)
  169.  {
  170.   dirty[i].x = dirty_sort[i].x;
  171.   dirty[i].y = dirty_sort[i].y;
  172.   dirty[i].z = dirty_sort[i].z;
  173.   dirty[i].w = dirty_sort[i].w;
  174.   dirty[i].h = dirty_sort[i].h;
  175.   dirty[i].pic = dirty_sort[i].pic;
  176.  }
  177. }
  178.  
  179. void Draw_Block(int x, int y, int z, BITMAP *pic)
  180. {
  181.  int k;
  182.  
  183.  if ((x < 0) || (y < 0) || (x > 19) || (y > 14)) return;
  184.  
  185.  if ((map[x][y][z] == 0) && (!z))
  186.  {
  187.   if (map[x][y - 1][z] == 0) blit(back, pic, x*32, y*32 - z*8, x*32, y*32 - z*8, 32, 40);
  188.   else blit(back, pic, x*32, y*32 - z*8 + 8, x*32, y*32 - z*8 + 8, 32, 32);
  189.  }
  190.  if (map[x][y][z] == SOLID)
  191.  {
  192.   k = 0;
  193.  
  194.   if (map[x][y - 1][z] != SOLID) k = 1;
  195.   if (map[x + 1][y][z] != SOLID) k += 2;
  196.   if (map[x][y + 1][z] != SOLID) k += 4;
  197.   if (map[x - 1][y][z] != SOLID) k += 8;
  198.  
  199.   if (x == 0) k = k & 7;
  200.   if (x == 19) k = k & 13;
  201.   if (y == 0) k = k & 14;
  202.   if (y == 14) k = k & 11;
  203.  
  204.   if (z == 1)
  205.   {
  206.    if (x == 0) k = k | 8;
  207.    if (x == 19) k = k | 2;
  208.    if (y == 0) k = k | 1;
  209.    if (y == 14) k = k | 4;
  210.   }
  211.  
  212.   masked_blit(gfx, pic, (k%4)*32 + z*128, 280 + (k/4)*40, x*32, y*32 - z*8, 32, 40);
  213.  }
  214.  
  215.  if (map[x][y][z] == BOX) masked_blit(box_pic, pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  216.  if (map[x][y][z] == AUDREY) masked_blit(ply_pic[0][0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  217.  if (map[x][y][z] == AN) masked_blit(ply_pic[1][0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  218.  if (map[x][y][z] == TOKEN) masked_blit(token_pic, pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  219.  
  220.  if (map[x][y][z] == RED_TELEPORT) masked_blit(teleport_pic[0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  221.  if (map[x][y][z] == GREEN_TELEPORT) masked_blit(teleport_pic[1], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  222.  if (map[x][y][z] == BLUE_TELEPORT) masked_blit(teleport_pic[2], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  223.  
  224.  if (map[x][y][z] == LASER_UP) masked_blit(laser_pic[0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  225.  if (map[x][y][z] == LASER_RIGHT) masked_blit(laser_pic[1], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  226.  if (map[x][y][z] == LASER_DOWN) masked_blit(laser_pic[2], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  227.  if (map[x][y][z] == LASER_LEFT) masked_blit(laser_pic[3], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  228.  if (map[x][y][z] == LASER_4WAY) masked_blit(laser_pic[4], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  229.  
  230.  if (map[x][y][z] == MIRROR_MINUS) masked_blit(mirror_pic[0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  231.  if (map[x][y][z] == MIRROR_PLUS) masked_blit(mirror_pic[1], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  232.  
  233.  if (map[x][y][z] == BOMB1) masked_blit(bomb_pic[0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  234.  if (map[x][y][z] == BOMB2) masked_blit(bomb_pic[1], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  235.  if (map[x][y][z] == BOMB3) masked_blit(bomb_pic[2], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  236.  
  237.  if (map[x][y][z] == LASER_FILTER) masked_blit(filter_pic, pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  238.  
  239.  if (map[x][y][z] == MON0) masked_blit(mon_pic[0][0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  240.  if (map[x][y][z] == MON1) masked_blit(mon_pic[0][0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  241.  if (map[x][y][z] == MON2) masked_blit(mon_pic[0][0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  242.  
  243.  if (map[x][y][z] == RED_SWITCH) masked_blit(switches_pic[0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  244.  if (map[x][y][z] == GREEN_SWITCH) masked_blit(switches_pic[1], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  245.  if (map[x][y][z] == BLUE_SWITCH) masked_blit(switches_pic[2], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  246.  
  247.  if (map[x][y][z] == RED_DOOR_CLOSE) masked_blit(door_pic[0], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  248.  if (map[x][y][z] == GREEN_DOOR_CLOSE) masked_blit(door_pic[1], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  249.  if (map[x][y][z] == BLUE_DOOR_CLOSE) masked_blit(door_pic[2], pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  250.  
  251.  if (map[x][y][z] == FALL) masked_blit(fall_pic, pic, 0, 0, x*32, y*32 - z*8, 32, 40);
  252. }
  253.  
  254. void Draw_Screen(void)
  255. {
  256.  int i, j, k;
  257.  
  258.  Sort_Dirty();
  259.  Draw_Area();
  260.  
  261.  for (j = 0; j < 15; j++)
  262.  for (i = 0; i < 20; i++)
  263.  if (map2[i][j]) blit(back, temp, i * 32, j * 32, i * 32, j * 32, 32, 40);
  264.  
  265.  for (j = 0; j < 15; j++)
  266.  {
  267.   for (i = 0; i < 20; i++)
  268.   if ((map2[i][j]) && (map[i][j][0])) Draw_Block(i, j, 0, temp);
  269.  
  270.   for (k = 0; k < dirty_count; k++)
  271.   {
  272.    if ((dirty[k].y/32 == j) && (dirty[k].z == 0))
  273.    masked_blit(dirty[k].pic, temp, 0, 0, dirty[k].x, dirty[k].y - dirty[k].z, dirty[k].w, dirty[k].h);
  274.  
  275.    if ((dirty[k].y/32 == j - 1) && (dirty[k].z != 0))
  276.    masked_blit(dirty[k].pic, temp, 0, 0, dirty[k].x, dirty[k].y - dirty[k].z, dirty[k].w, dirty[k].h);
  277.   }
  278.  
  279.   for (i = 0; i < 20; i++)
  280.   if (map2[i][j])
  281.   {
  282.    if (map_laser[i][j][0] == 1) masked_blit(beam_pic[0], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  283.    if (map_laser[i][j][0] == 2) masked_blit(beam_pic[1], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  284.    if (map_laser[i][j][0] == 3) masked_blit(beam_pic[2], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  285.    if (map_laser[i][j][0] & 4) masked_blit(beam_pic[3], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  286.    if (map_laser[i][j][0] & 8) masked_blit(beam_pic[4], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  287.    if (map_laser[i][j][0] & 16) masked_blit(beam_pic[5], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  288.    if (map_laser[i][j][0] & 32) masked_blit(beam_pic[6], temp, 0, 0, i*32, j*32 - 0*8, 32, 35);
  289.   }
  290.  
  291.   for (i = 0; i < 20; i++)
  292.   if ((map2[i][j]) && (map[i][j][1])) Draw_Block(i, j, 1, temp);
  293.  
  294.   for (i = 0; i < 20; i++)
  295.   if (map2[i][j])
  296.   {
  297.    if (map_laser[i][j][1] == 1) masked_blit(beam_pic[0], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  298.    if (map_laser[i][j][1] == 2) masked_blit(beam_pic[1], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  299.    if (map_laser[i][j][1] == 3) masked_blit(beam_pic[2], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  300.    if (map_laser[i][j][1] & 4) masked_blit(beam_pic[3], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  301.    if (map_laser[i][j][1] & 8) masked_blit(beam_pic[4], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  302.    if (map_laser[i][j][1] & 16) masked_blit(beam_pic[5], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  303.    if (map_laser[i][j][1] & 32) masked_blit(beam_pic[6], temp, 0, 0, i*32, j*32 - 1*8, 32, 35);
  304.   }
  305.  }
  306.  
  307.  for (i = 0; i < dirty_count; i++)
  308.  blit(temp, screen, dirty[i].x - 1, dirty[i].y - dirty[i].z - 1, dirty[i].x - 1, dirty[i].y - dirty[i].z - 1, dirty[i].w + 2, dirty[i].h + 2);
  309.  
  310.  dirty_count = 0;
  311.  
  312.  Draw_Status();
  313. }
  314. void Map_Setup(void)
  315. {
  316.  int i, j, k, l;
  317.  
  318.  box_count = 0;
  319.  mon_count = 0;
  320.  explode_count = 0;
  321.  door_count = 0;
  322.  switches_count = 0;
  323.  
  324.  for (k = 0; k < 2; k++)
  325.  for (j = 0; j < 15; j++)
  326.  for (i = 0; i < 20; i++)
  327.  {
  328.   map_door[i][j][k] = 0;
  329.   map_laser[i][j][k] = 0;
  330.  
  331.   if (map[i][j][k] & PUSH)
  332.   {
  333.    box[box_count].x = i*32;
  334.    box[box_count].y = j*32;
  335.    box[box_count].z = k*8;
  336.    box[box_count].dx = 0;
  337.    box[box_count].dy = 0;
  338.    box[box_count].dz = 0;
  339.    box[box_count].type = map[i][j][k];
  340.  
  341.    if (map[i][j][k] == BOX) box[box_count].pic = box_pic;
  342.    if (map[i][j][k] == MIRROR_MINUS) box[box_count].pic = mirror_pic[0];
  343.    if (map[i][j][k] == MIRROR_PLUS) box[box_count].pic = mirror_pic[1];
  344.    if (map[i][j][k] == BOMB1) box[box_count].pic = bomb_pic[0];
  345.    if (map[i][j][k] == BOMB2) box[box_count].pic = bomb_pic[1];
  346.    if (map[i][j][k] == BOMB3) box[box_count].pic = bomb_pic[2];
  347.    if (map[i][j][k] == LASER_UP) box[box_count].pic = laser_pic[0];
  348.    if (map[i][j][k] == LASER_RIGHT) box[box_count].pic = laser_pic[1];
  349.    if (map[i][j][k] == LASER_DOWN) box[box_count].pic = laser_pic[2];
  350.    if (map[i][j][k] == LASER_LEFT) box[box_count].pic = laser_pic[3];
  351.    if (map[i][j][k] == LASER_4WAY) box[box_count].pic = laser_pic[4];
  352.  
  353.    if (map[i][j][k] & LASER) box[box_count].dir = map[i][j][k] & 15;
  354.  
  355.    box_count++;
  356.   }
  357.  
  358.   if (map[i][j][k] & MONSTER)
  359.   {
  360.    mon[mon_count].x = i*32;
  361.    mon[mon_count].y = j*32;
  362.    mon[mon_count].z = k*8;
  363.    mon[mon_count].dx = -1;
  364.    mon[mon_count].dy = 0;
  365.    mon[mon_count].dz = 0;
  366.  
  367.    mon[mon_count].type = map[i][j][k];
  368.  
  369.    mon[mon_count].dir = 8;
  370.    mon[mon_count].state = 1;
  371.    mon[mon_count].speed = 3;
  372.    mon[mon_count].count = 0;
  373.  
  374.    if (map[i][j][k] == MON2) mon[mon_count].speed = 1;
  375.  
  376.    Monster_Change_Dir(mon_count, i, j, k);
  377.  
  378.    mon_count++;
  379.  
  380.    map[i][j][k] = 0;
  381.   }
  382.  
  383.   if (map[i][j][k] & DOOR)
  384.   {
  385.    door[door_count].x = i;
  386.    door[door_count].y = j;
  387.    door[door_count].z = k;
  388.    door[door_count].c = map[i][j][k] & 7;
  389.    door[door_count].state = CLOSE;
  390.    door_count++;
  391.    map_door[i][j][k] = map[i][j][k] & 7;
  392.   }
  393.  
  394.   if (map[i][j][k] & SWITCH)
  395.   {
  396.    switches[switches_count].x = i;
  397.    switches[switches_count].y = j;
  398.    switches[switches_count].z = k;
  399.    switches[switches_count].c = map[i][j][k] & 7;
  400.    switches_count++;
  401.   }
  402.  }
  403. }
  404.  
  405. void Draw_Status(void)
  406. {
  407. }
  408.